﻿/*
Nombre:                         CuentaDao
Descripcion:                    Implementacion que maneja las funciones principales sobre el catalogo de cuentas manejado en la capa de persistencia 
Dependencias:                 
Fecha de creación:              20081109
Autor:                          VMORALES
Fecha de modifcación:         
Responsable:                  
Num. de modifcación:            0
*/

#region Imports

using Electrocucaracha.AdminPersonal.DAO.Entidades;
using Electrocucaracha.AdminPersonal.DAO.Acciones;
using Common.Logging;
using System;

#endregion

namespace Electrocucaracha.AdminPersonal.DAO
{
    /// <summary>
    /// Implementacion que maneja las funciones principales sobre el catalogo de cuentas manejado en la capa de persistencia
    /// </summary>
    public class CuentaDao : BaseDao, ICuentaDao
    {
        #region Constantes

        #endregion

        #region Miembros

		private static readonly ILog log = LogManager.GetLogger(typeof(CuentaDao));
        private static CuentaDao instancia = new CuentaDao();

        #endregion

        #region Propiedades

        /// <summary>
        /// Obtiene la instancia unica para el catalogo de cuentas
        /// </summary>
        public static CuentaDao Instancia
        {
            get
            {
				log.Info("Inicio CuentaDao.Instancia.get");

                if (instancia == null)
                {
                    instancia = new CuentaDao();
                }

                log.Info("Fin CuentaDao.Instancia.get");

                return instancia;
            }
        }//Instancia

        #endregion

        #region Constructores

        private CuentaDao()
            : base()
        {
            log.Info("Inicio CuentaDao.ctor()");

            log.Info("Fin CuentaDao.ctor()");
        }//CuentaDao

        #endregion

        #region Funciones

        /// <summary>
        /// Funcion que valida si existe una cuenta en la capa de persistencia que tenga la misma descripcion
        /// </summary>
        /// <param name="descripcion">Cadena a buscar en la base de datos</param>
        /// <returns>Verdadero en caso de que no exista ningun banco</returns>
        private bool Existe(string descripcion)
        {
            log.Info("Inicio CuentaDao.Existe(string descripcion)");

            log.Debug("Descripcion a buscar : " + descripcion);
            bool respuesta = this.ObtenerPorDescripcion(descripcion) != null;
            log.Debug("Existe cuenta por descripcion : " + respuesta);

            log.Info("Fin CuentaDao.Existe(string descripcion)");

            return respuesta;
        }//Existe

        #endregion

        #region IGenericoDao

        /// <summary>
        /// Funcion que agrega un objeto de tipo cuenta a la capa de persistencia
        /// </summary>
        /// <param name="cuenta">Cuenta a ser agregada en la capa de persistencia</param>
        /// <returns>Verdadero en caso de su correcta aserción</returns>
        public bool Agregar(ref CuentaDTO cuenta)
        {
            log.Info("Inicio CuentaDao.Agregar(ref CuentaDTO cuenta)");

            //Validacion de parametros
            Validar(cuenta, Validaciones.Nulo | Validaciones.DescripcionVacia);

            Accion accion = admin.ObtenerAccion(CatalogoAcciones.Cuenta.AGREGAR);
            log.Debug("Accion : " + accion);
			accion.Parametros[Accion.INPUT] = cuenta;
            accion.Parametros[Accion.OUTPUT] = false;

            //Se compara solo su descripcion ya que el identificador carece de importancia
            if (!this.Existe(cuenta))
            {
				log.Info("Insercion de la cuenta");
                admin.Ejecutar(accion);
            }

			log.Info("Fin CuentaDao.Agregar(ref CuentaDTO cuenta)");

            return (bool)accion.Parametros[Accion.OUTPUT];
        }//Agregar

        /// <summary>
        /// Funcion que agrega un conjunto de objetos de tipo cuenta a la capa de persistencia
        /// </summary>
        /// <param name="cuentas">Conjunto de objetos de tipo cuenta a ser agregados</param>
        /// <returns>El indice de la ultima cuenta la cual fue agregada con exito a la capa de persistencia</returns>
        public int Agregar(ref CuentaDTO[] cuentas)
        {
            log.Info("Inicio CuentaDao.Agregar(ref CuentaDTO[] cuentas)");

            //Validacion de datos
            Validar(cuentas, Validaciones.Nulo & Validaciones.DescripcionVacia);

            int i = 0;
            for (;i < cuentas.Length; i++)
            {
                if (!Agregar(ref cuentas[i]))
                {
                    log.Error("No se pudo agregar la cuenta con la descripcion : " + cuentas[i].Descripcion);
                    break;
                }
            }

            log.Info("Fin CuentaDao.Agregar(ref CuentaDTO[] cuentas)");

            return i;
        }//Agregar

        /// <summary>
        /// Funcion que elimina(en caso de existir) un objeto de tipo cuenta de la capa de persistencia
        /// </summary>
        /// <param name="cuenta">Objeto a ser eliminado</param>
        /// <returns>Verdadero en caso de eliminacion falso en caso contrario</returns>
        public bool Eliminar(CuentaDTO cuenta)
        {
            log.Info("Inicio CuentaDao.Eliminar(CuentaDTO cuenta)");

            //Validacion de parametros
            if (!Existe(cuenta))
            {
                log.Error("No existe la cuenta a eliminar");
                throw new DAOException("No existe la cuenta a eliminar");
            }

            Accion accion = admin.ObtenerAccion(CatalogoAcciones.Cuenta.ELIMINAR);
            log.Debug("Accion : " + accion);
			accion.Parametros[Accion.INPUT] = cuenta;
            admin.Ejecutar(accion);

            log.Info("Fin CuentaDao.Eliminar(CuentaDTO cuenta)");

            return (bool)accion.Parametros[Accion.OUTPUT];
        }//Eliminar

        /// <summary>
        /// Funcion que elimina(en caso de existir) un conjunto de objetos de tipo cuenta de la capa de persistencia
        /// </summary>
        /// <param name="cuentas">Conjunto de objetos a ser eliminados</param>
        /// <returns>El indice de la ultima cuenta la cual fue eliminada con exito de la capa de persistencia</returns>
        public int Eliminar(CuentaDTO[] cuentas)
        {
            log.Info("Inicio CuentaDao.Eliminar(CuentaDTO[] cuentas)");

            int i = 0;
            for (; i < cuentas.Length; i++)
            {
                if (!Eliminar(cuentas[i]))
                {
                    log.Error("No se pudo eliminar la cuenta con la descripcion : " + cuentas[i].Descripcion);
                    break;
                }
            }

            log.Info("Fin CuentaDao.Eliminar(CuentaDTO[] cuentas)");

            return i;
        }//Eliminar

        /// <summary>
        /// Funcion que obtiene una cuenta, de la capa de persistencia, a partir de su identificador
        /// </summary>
        /// <param name="id">Identificador de la cuenta a obtener</param>
        /// <returns>Un objeto de tipo cuenta en caso de encontrarlo nulo en caso contrario</returns>
        public CuentaDTO Obtener(int id)
        {
			log.Info("Inicio CuentaDao.Obtener(int id)");

            //Validacion de parametros
            if (id < -1)
            {
                log.Error("No existen cuentas con identificadores negativos");
                throw new DAOException("No existen cuentas con identificadores negativos");
            }

            CuentaDTO resultado = null;
			Accion accion = admin.ObtenerAccion(CatalogoAcciones.Cuenta.OBTENER);
            accion.Parametros[Accion.INPUT] = id;
            log.Debug("Accion : " + accion);
            admin.Ejecutar(accion);
            resultado = accion.Parametros[Accion.OUTPUT] as CuentaDTO;

            log.Info("Fin CuentaDao.Obtener(int id)");

            return resultado;
        }//Obtener

        /// <summary>
        /// Funcion que devuelve todas las cuentas registradas en la capa de persistencia
        /// </summary>
        /// <returns>Conjunto de cuentas</returns>
        public CuentaDTO[] Obtener()
        {
            log.Info("Inicio CuentaDao.Obtener()");

            CuentaDTO[] resultado = null;
            Accion accion = admin.ObtenerAccion(CatalogoAcciones.Cuenta.OBTENER_TODOS);
            log.Debug("Accion : " + accion);
            admin.Ejecutar(accion);
            resultado = accion.Parametros[Accion.OUTPUT] as CuentaDTO[];

            if (resultado != null && resultado.Length == 0)
            {
                log.Warn("Reseteando el valor obtenido");
                resultado = null;
            }

            log.Info("Fin BancoDao.Obtener()");

            return resultado;
        }//Obtener

        /// <summary>
        /// Funcion que actualiza en la capa de persistencia el objeto solicitado
        /// </summary>
        /// <param name="cuenta">Objeto a ser actualizado en la capa de persistencia</param>
        /// <returns>Verdadero en caso de exito falso en caso contrario</returns>
        public bool Actualizar(CuentaDTO cuenta)
        {
            log.Info("Inicio CuentaDao.Actualizar(CuentaDTO cuenta)");

            //Validacion de parametros
            Validar(cuenta, Validaciones.Nulo | Validaciones.IdentificadorNegativo);
            if (!Existe(cuenta))
            {
                log.Error("No existe la cuenta a actualizar");
                throw new DAOException("No existe la cuenta a actualizar");
            }

            Accion accion = admin.ObtenerAccion(CatalogoAcciones.Cuenta.ACTUALIZAR);
            log.Debug("Accion : " + accion);
            accion.Parametros[Accion.INPUT] = cuenta;
            admin.Ejecutar(accion);

			log.Info("Fin CuentaDao.Actualizar(CuentaDTO cuenta)");

			return (bool)accion.Parametros[Accion.OUTPUT];
        }//Actualizar

        /// <summary>
        /// Funcion que actualiza en la capa de persistencia un conjunto de bancos
        /// </summary>
        /// <param name="cuentas">Conjunto de bancos a actualizar en la capa de persistencia</param>
        /// <returns>El indice de la ultima cuenta la cual fue actualizada con exito a la capa de persistencia</returns>
        public int Actualizar(CuentaDTO[] cuentas)
        {
            log.Info("Inicio CuentaDao.Actualizar(CuentaDTO[] cuentas)");

            //Validacion de datos
            Validar(cuentas, Validaciones.Nulo & Validaciones.IdentificadorNegativo);

            int i = 0;
            for (; i < cuentas.Length; i++)
            {
                if (!Actualizar(cuentas[i]))
                {
                    log.Error("No se pudo actualizar la cuenta con id : " + cuentas[i].Id);
                    break;
                }
            }

            log.Info("Fin CuentaDao.Actualizar(CuentaDTO[] cuentas)");

            return i;
        }//Actualizar

        /// <summary>
        /// Funcion que determina si el objeto actualmente se encuentra registrado en la capa de persistencia
        /// </summary>
        /// <param name="cuenta">Objeto a validar su existencia</param>
        /// <returns>Verdadero en caso de que no exista ninguna cuenta</returns>
        public bool Existe(CuentaDTO cuenta)
        {
            log.Info("Inicio CuentaDao.Existe(CuentaDTO cuenta)");

            //Validacion de datos
            Validar(cuenta, Validaciones.Nulo);

            bool existe = this.Obtener(cuenta.Id) != null;
            log.Debug("Busqueda por id : " + existe);

            log.Info("Fin CuentaDao.Existe(CuentaDTO cuenta)");

            return existe;
        }//Existe

        /// <summary>
        /// Funcion que devuelve la cantidad de cuentas registradas en la capa de persistencia
        /// </summary>
        /// <returns>Cantidad de cuentas registradas</returns>
        public int ObtenerCantidad()
        {
            log.Info("Inicio CuentaDao.ObtenerCantidad()");

            Accion accion = admin.ObtenerAccion(CatalogoAcciones.Cuenta.OBTENER_CANTIDAD);
            log.Debug("Accion : " + accion);
            admin.Ejecutar(accion);

            log.Info("Fin CuentaDao.ObtenerCantidad()");

            return (int)accion.Parametros[Accion.OUTPUT];
        }//ObtenerCantidad

        /// <summary>
        /// Funcion que resetea el identificador del catalogo de cuentas al menor registrado en la tabla
        /// </summary>
        public void ResetearId()
        {
            log.Info("Inicio CuentaDao.ResetearId()");

            Accion accion = admin.ObtenerAccion(CatalogoAcciones.Cuenta.RESETEAR_ID);
            log.Debug("Accion : " + accion);
            admin.Ejecutar(accion);

            log.Info("Fin CuentaDao.ResetearId()");
        }//ResetearId

        /// <summary>
        /// Funcion que valida los campos correctos del objeto
        /// </summary>
        /// <param name="banco">Objeto a ser validado</param>
        /// <param name="validacion">Opciones de validacion de los campos</param>
        public void Validar(CuentaDTO cuenta, Validaciones validacion)
        {
            log.Info("Inicio CuentaDao.Validar(CuentaDTO cuenta, Validaciones validacion)");

            if ((validacion & Validaciones.Nulo) == Validaciones.Nulo)
            {
                log.Debug("Validacion de objeto nulo");
                if (cuenta == null)
                {
                    log.Error("El objeto es nulo");
                    throw new DAOException("El objeto es nulo");
                }
            }

            if ((validacion & Validaciones.DescripcionVacia) == Validaciones.DescripcionVacia)
            {
                log.Debug("Validacion de descripcion vacia");
                if (string.IsNullOrEmpty(cuenta.Descripcion))
                {
                    log.Error("La cuenta no tiene descripcion alguna");
                    throw new DAOException("La cuenta no tiene descripcion alguna");
                }
            }

            if ((validacion & Validaciones.IdentificadorNegativo) == Validaciones.IdentificadorNegativo)
            {
                log.Debug("Validacion de identificador negativo");
                if (cuenta.Id < 0)
                {
                    log.Error("La cuenta no puede tener un identificador negativo");
                    throw new DAOException("La cuenta no puede tener un identificador negativo");
                }
            }

            log.Info("Fin CuentaDao.Validar(CuentaDTO cuenta, Validaciones validacion)");
        }//Validar

        /// <summary>
        /// Funcion que valida cada uno de los elementos de un conjunto de bancos
        /// </summary>
        /// <param name="banco">Conjunto de cuentas a ser validadas</param>
        /// <param name="validacion">Opciones de validacion de los campos</param>
        public void Validar(CuentaDTO[] cuentas, Validaciones validacion)
        {
            log.Info("Inicio BancoDao.Validar(CuentaDTO[] cuentas, Validaciones validacion)");

            if (cuentas == null)
            {
                log.Error("El objeto es nulo");
                throw new DAOException("El objeto es nulo");
            }

            foreach (CuentaDTO c in cuentas)
            {
                Validar(c, validacion);
            }

            log.Info("Fin BancoDao.Validar(CuentaDTO[] cuentas, Validaciones validacion)");
        }//Validar

        #endregion

        #region ICuentaDao

        /// <summary>
        /// Funcion que obtiene todas las cuentas que concidan con la descripcion solicitada
        /// </summary>
        /// <param name="descripcion">Descripcion a buscar en la capa de persistencia</param>
        /// <returns>Conjunto de objetos que comparten la misma descripcion</returns>
        public CuentaDTO[] ObtenerPorDescripcion(string descripcion)
        {
            log.Info("Inicio CuentaDao.ObtenerPorDescripcion(string descripcion)");

			CuentaDTO[] resultado = null;
            Accion accion = admin.ObtenerAccion(CatalogoAcciones.Cuenta.OBTENER_POR_DESCRIPCION);
            log.Debug("Accion : " + accion);
            accion.Parametros[Accion.INPUT] = descripcion;
            admin.Ejecutar(accion);
            resultado = accion.Parametros[Accion.OUTPUT] as CuentaDTO[];

            if (resultado != null && resultado.Length == 0)
            {
                log.Warn("Reseteando el valor obtenido");
                resultado = null;
            }

			log.Info("Fin CuentaDao.ObtenerPorDescripcion(string descripcion)");

            return resultado;
        }//ObtenerPorDescripcion

        /// <summary>
        /// Funcion que obtiene todas las cuentas que tengan en su descripcion el parametro solicitado
        /// </summary>
        /// <param name="descripcion">Descripcion a contener en las descripciones de los objetos</param>
        /// <returns>Conjunto de objetos que incluyen en su descripcion en parametro deseado</returns>
        public CuentaDTO[] ObtenerPorDescripcionSimilar(string descripcion)
        {
            log.Info("Inicio CuentaDao.ObtenerPorDescripcionSimilar(string descripcion)");

            CuentaDTO[] resultado = null;
            Accion accion = admin.ObtenerAccion(CatalogoAcciones.Cuenta.OBTENER_POR_DESCRIPCION_SIMILAR);
            accion.Parametros[Accion.INPUT] = descripcion;
            log.Debug("Accion : " + accion);
            admin.Ejecutar(accion);
            resultado = accion.Parametros[Accion.OUTPUT] as CuentaDTO[];

            if (resultado != null && resultado.Length == 0)
            {
                log.Warn("Reseteando el valor obtenido");
                resultado = null;
            }

            log.Info("Fin CuentaDao.ObtenerPorDescripcionSimilar(string descripcion)");

            return resultado;
        }//ObtenerPorDescripcionSimilar

        /// <summary>
        /// Funcion que devuelve todas las cuentas de un banco en especifico capturadas en la capa de persistencia
        /// </summary>
        /// <param name="banco">Banco a filtrar</param>
        /// <returns>Conjunto de cuentas</returns>
        public CuentaDTO[] Obtener(BancoDTO banco)
        {
            log.Info("Inicio CuentaDao.Obtener(BancoDTO banco)");

            //Validacion de parametros
            if (banco == null)
            {
                log.Error("Banco no especificado para buscar sus cuentas");
                throw new DAOException("Banco no especificado para buscar sus cuentas");
            }

            CuentaDTO[] resultado = null;
            Accion accion = admin.ObtenerAccion(CatalogoAcciones.Cuenta.OBTENER_POR_BANCO);
            log.Debug("Accion : " + accion);
            accion.Parametros[Accion.INPUT] = banco;
            admin.Ejecutar(accion);
            resultado = accion.Parametros[Accion.OUTPUT] as CuentaDTO[];

            if (resultado != null && resultado.Length == 0)
            {
                log.Warn("Reseteando el valor obtenido");
                resultado = null;
            }

            log.Info("Fin CuentaDao.Obtener(BancoDTO banco)");

            return resultado;
        }//Obtener

        /// <summary>
        /// Funcion que devuelve todas las cuentas de un titular en especifico capturadas en la capa de persistencia
        /// </summary>
        /// <param name="titular">Titular a filtrar</param>
        /// <returns>Conjunto de cuentas</returns>
        public CuentaDTO[] Obtener(TitularDTO titular)
        {
            log.Info("Inicio CuentaDao.Obtener(TitularDTO titular)");

            //Validacion de parametros
            if (titular == null)
            {
                log.Error("Titular no especificado para buscar sus cuentas");
                throw new DAOException("Titular no especificado para buscar sus cuentas");
            }

            CuentaDTO[] resultado = null;
            Accion accion = admin.ObtenerAccion(CatalogoAcciones.Cuenta.OBTENER_POR_TITULAR);
            log.Debug("Accion : " + accion);
            accion.Parametros[Accion.INPUT] = titular;
            admin.Ejecutar(accion);
            resultado = accion.Parametros[Accion.OUTPUT] as CuentaDTO[];

            if (resultado != null && resultado.Length == 0)
            {
                log.Warn("Reseteando el valor obtenido");
                resultado = null;
            }

            log.Info("Fin CuentaDao.Obtener(TitularDTO titular)");

            return resultado;
        }//Obtener

        /// <summary>
        /// Funcion que elimina todas las cuentas de un banco en especifico capturadas en la capa de persistencia
        /// </summary>
        /// <param name="banco">Banco a eliminar cuentas</param>
        /// <returns>Verdadero en caso de su correcta eliminacion</returns>
        public bool Eliminar(BancoDTO banco)
        {
            log.Info("Inicio CuentaDao.Eliminar(BancoDTO banco)");

            //Validacion de parametros
            if (banco != null)
            {
                log.Error("Banco no especificado para eliminar sus cuentas asociadas");
                throw new DAOException("Banco no especificado para eliminar sus cuentas asociadas");
            }

            Accion accion = admin.ObtenerAccion(CatalogoAcciones.Cuenta.ELIMINAR_POR_BANCO);
            log.Debug("Accion : " + accion);
            accion.Parametros[Accion.INPUT] = banco;
            admin.Ejecutar(accion);

            log.Info("Fin CuentaDao.Eliminar(BancoDTO banco)");

            return (bool)accion.Parametros[Accion.OUTPUT];
        }//Eliminar

        /// <summary>
        /// Funcion que elimina todas las cuentas de un titular en especifica capturadas en la capa de persistencia
        /// </summary>
        /// <param name="titular">Titular a eliminar cuentas</param>
        /// <returns>Verdadero en caso de su correcta eliminacion</returns>
        public bool Eliminar(TitularDTO titular)
        {
            log.Info("Inicio CuentaDao.Eliminar(TitularDTO titular)");

            //Validacion de parametros
            if (titular != null)
            {
                log.Error("Titular no especificado para eliminar sus cuentas asociadas");
                throw new DAOException("Titular no especificado para eliminar sus cuentas asociadas");
            }

            Accion accion = admin.ObtenerAccion(CatalogoAcciones.Cuenta.ELIMINAR_POR_TITULAR);
            log.Debug("Accion : " + accion);
            accion.Parametros[Accion.INPUT] = titular;
            admin.Ejecutar(accion);

            log.Info("Fin CuentaDao.Eliminar(TitularDTO titular)");

            return (bool)accion.Parametros[Accion.OUTPUT];
        }//Eliminar

        #endregion

        #region IActivo

        /// <summary>
        /// Funcion que devuelve todos los objetos con estatus de activo de la capa de persistencia
        /// </summary>
        /// <returns>Conjunto de objetos con el mismo estatus de activo</returns>
        public CuentaDTO[] ObtenerActivos()
        {
            log.Info("Inicio CuentaDao.ObtenerActivos()");

            CuentaDTO[] resultado = null;
            Accion accion = admin.ObtenerAccion(CatalogoAcciones.Cuenta.OBTENER_ACTIVOS);
            log.Debug("Accion : " + accion);
            admin.Ejecutar(accion);
            resultado = accion.Parametros[Accion.OUTPUT] as CuentaDTO[];

            if (resultado != null && resultado.Length == 0)
            {
                log.Warn("Reseteando el valor obtenido");
                resultado = null;
            }

            log.Info("Fin CuentaDao.ObtenerActivos()");

            return resultado;
        }//ObtenerActivos

        /// <summary>
        /// Funcion que devuelve todos los objetos con estatus de inactivo de la capa de persistencia
        /// </summary>
        /// <returns>Conjunto de objetos con el mismo estatus de inactivo</returns>
        public CuentaDTO[] ObtenerInactivos()
        {
            log.Info("Inicio CuentaDao.ObtenerInactivos()");

            CuentaDTO[] resultado = null;
            Accion accion = admin.ObtenerAccion(CatalogoAcciones.Cuenta.OBTENER_INACTIVOS);
            log.Debug("Accion : " + accion);
            admin.Ejecutar(accion);
            resultado = accion.Parametros[Accion.OUTPUT] as CuentaDTO[];

            if (resultado != null && resultado.Length == 0)
            {
                log.Warn("Reseteando el valor obtenido");
                resultado = null;
            }

            log.Info("Fin CuentaDao.ObtenerInactivos()");

            return resultado;
        }//ObtenerInactivos

        /// <summary>
        /// Funcion que actualiza el estatus a activo de la cuenta en la capa de persistencia
        /// </summary>
        /// <param name="cuentaInactiva">Objeto con el estatus a actualizar</param>
        /// <returns>Verdadero en caso de exito falso en caso contrario</returns>
        public bool Activar(CuentaDTO cuentaInactiva)
        {
            log.Info("Inicio CuentaDao.Activar(CuentaDTO cuentaInactiva)");

            if (!Existe(cuentaInactiva))
            {
                log.Error("No existe la cuenta a activar");
                throw new DAOException("No existe la cuenta a activar");
            }

            Accion accion = admin.ObtenerAccion(CatalogoAcciones.Cuenta.ACTIVAR);
            log.Debug("Accion : " + accion);
            bool respuesta = false;
            accion.Parametros[Accion.INPUT] = cuentaInactiva;

            admin.Ejecutar(accion);
            respuesta = (bool)accion.Parametros[Accion.OUTPUT];
            cuentaInactiva.Activo = respuesta ? true : cuentaInactiva.Activo;

            log.Info("Fin CuentaDao.Activar(CuentaDTO cuentaInactiva)");

            return respuesta;
        }//Activar

        /// <summary>
        /// Funcion que actualiza el estatus a desactivo de la cuenta en la capa de persistencia
        /// </summary>
        /// <param name="cuentaActiva">Objeto con el estatus a actualizar</param>
        /// <returns>Verdadero en caso de exito falso en caso contrario</returns>
        public bool Desactivar(CuentaDTO cuentaActiva)
        {
            log.Info("Inicio CuentaDao.Desactivar(CuentaDTO cuentaActiva)");

            if (!Existe(cuentaActiva))
            {
                log.Error("No existe la cuenta a desactivar");
                throw new DAOException("No existe la cuenta a desactivar");
            }

            Accion accion = admin.ObtenerAccion(CatalogoAcciones.Cuenta.DESACTIVAR);
            log.Debug("Accion : " + accion);
            bool respuesta = false;
            accion.Parametros[Accion.INPUT] = cuentaActiva;

            admin.Ejecutar(accion);
            respuesta = (bool)accion.Parametros[Accion.OUTPUT];
            cuentaActiva.Activo = respuesta ? false : cuentaActiva.Activo;

            log.Info("Fin CuentaDao.Desactivar(CuentaDTO cuentaActiva)");

            return respuesta;
        }//Desactivar

        #endregion

    }//CuentaDao
}//Electrocucaracha.AdminPersonal.DAO